home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Blender 2.49b / blender-2.49b-windows.exe / $_4_ / .blender / scripts / mesh_skin.py < prev    next >
Text File  |  2009-08-31  |  18KB  |  640 lines
  1. #!BPY
  2.  
  3. """
  4. Name: 'Skin Faces/Edge-Loops'
  5. Blender: 243
  6. Group: 'MeshFaceKey'
  7. Tooltip: 'Select 2 vert loops, then run this script.'
  8. """
  9.  
  10. __author__ = "Campbell Barton AKA Ideasman"
  11. __url__ = ["blenderartists.org", "www.blender.org"]
  12. __version__ = "1.1 2006/12/26"
  13.  
  14. __bpydoc__ = """\
  15. With this script vertex loops can be skinned: faces are created to connect the
  16. selected loops of vertices.
  17.  
  18. Usage:
  19.  
  20. In mesh Edit mode select the vertices of the loops (closed paths / curves of
  21. vertices: circles, for example) that should be skinned, then run this script.
  22. A pop-up will provide further options, if the results of a method are not adequate try one of the others.
  23. """
  24.  
  25.  
  26. # $Id: mesh_skin.py 20333 2009-05-22 03:45:46Z campbellbarton $
  27. #
  28. # -------------------------------------------------------------------------- 
  29. # Skin Selected edges 1.0 By Campbell Barton (AKA Ideasman)
  30. # -------------------------------------------------------------------------- 
  31. # ***** BEGIN GPL LICENSE BLOCK ***** 
  32. # 
  33. # This program is free software; you can redistribute it and/or 
  34. # modify it under the terms of the GNU General Public License 
  35. # as published by the Free Software Foundation; either version 2 
  36. # of the License, or (at your option) any later version. 
  37. # 
  38. # This program is distributed in the hope that it will be useful, 
  39. # but WITHOUT ANY WARRANTY; without even the implied warranty of 
  40. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
  41. # GNU General Public License for more details. 
  42. # 
  43. # You should have received a copy of the GNU General Public License 
  44. # along with this program; if not, write to the Free Software Foundation, 
  45. # Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  46. # 
  47. # ***** END GPL LICENCE BLOCK ***** 
  48. # -------------------------------------------------------------------------- 
  49.  
  50. # Made by Ideasman/Campbell 2005/06/15 - cbarton@metavr.com
  51.  
  52. import Blender
  53. import bpy
  54. from Blender import Window
  55. from Blender.Mathutils import MidpointVecs, Vector
  56. from Blender.Mathutils import AngleBetweenVecs as _AngleBetweenVecs_
  57. import BPyMessages
  58.  
  59. from Blender.Draw import PupMenu
  60.  
  61. BIG_NUM = 1<<30
  62.  
  63. global CULL_METHOD
  64. CULL_METHOD = 0
  65.  
  66. def AngleBetweenVecs(a1,a2):
  67.     try:
  68.         return _AngleBetweenVecs_(a1,a2)
  69.     except:
  70.         return 180.0
  71.  
  72. class edge(object):
  73.     __slots__ = 'v1', 'v2', 'co1', 'co2', 'length', 'removed', 'match', 'cent', 'angle', 'next', 'prev', 'normal', 'fake'
  74.     def __init__(self, v1,v2):
  75.         self.v1 = v1
  76.         self.v2 = v2
  77.         co1, co2= v1.co, v2.co
  78.         self.co1= co1
  79.         self.co2= co2
  80.         
  81.         # uv1 uv2 vcol1 vcol2 # Add later
  82.         self.length = (co1 - co2).length
  83.         self.removed = 0    # Have we been culled from the eloop
  84.         self.match = None    # The other edge were making a face with
  85.         
  86.         self.cent= MidpointVecs(co1, co2)
  87.         self.angle= 0.0
  88.         self.fake= False
  89.  
  90. class edgeLoop(object):
  91.     __slots__ = 'centre', 'edges', 'normal', 'closed', 'backup_edges'
  92.     def __init__(self, loop, me, closed): # Vert loop
  93.         # Use next and prev, nextDist, prevDist
  94.         
  95.         # Get Loops centre.
  96.         fac= len(loop)
  97.         verts = me.verts
  98.         self.centre= reduce(lambda a,b: a+verts[b].co/fac, loop, Vector())
  99.         
  100.         # Convert Vert loop to Edges.
  101.         self.edges = [edge(verts[loop[vIdx-1]], verts[loop[vIdx]]) for vIdx in xrange(len(loop))]
  102.         
  103.         if not closed:
  104.             self.edges[0].fake = True # fake edge option
  105.             
  106.         self.closed = closed
  107.             
  108.         
  109.         # Assign linked list
  110.         for eIdx in xrange(len(self.edges)-1):
  111.             self.edges[eIdx].next = self.edges[eIdx+1]
  112.             self.edges[eIdx].prev = self.edges[eIdx-1]
  113.         # Now last
  114.         self.edges[-1].next = self.edges[0]
  115.         self.edges[-1].prev = self.edges[-2]
  116.         
  117.         
  118.         
  119.         # GENERATE AN AVERAGE NORMAL FOR THE WHOLE LOOP.
  120.         self.normal = Vector()
  121.         for e in self.edges:
  122.             n = (self.centre-e.co1).cross(self.centre-e.co2)
  123.             # Do we realy need tot normalize?
  124.             n.normalize()
  125.             self.normal += n
  126.             
  127.             # Generate the angle
  128.             va= e.cent - e.prev.cent
  129.             vb= e.next.cent - e.cent
  130.             
  131.             e.angle= AngleBetweenVecs(va, vb)
  132.         
  133.         # Blur the angles
  134.         #for e in self.edges:
  135.         #    e.angle= (e.angle+e.next.angle)/2
  136.         
  137.         # Blur the angles
  138.         #for e in self.edges:
  139.         #    e.angle= (e.angle+e.prev.angle)/2
  140.             
  141.         self.normal.normalize()
  142.         
  143.         # Generate a normal for each edge.
  144.         for e in self.edges:
  145.             
  146.             n1 = e.co1
  147.             n2 = e.co2
  148.             n3 = e.prev.co1
  149.             
  150.             a = n1-n2
  151.             b = n1-n3
  152.             normal1 = a.cross(b)
  153.             normal1.normalize()
  154.             
  155.             n1 = e.co2
  156.             n3 = e.next.co2
  157.             n2 = e.co1
  158.             
  159.             a = n1-n2
  160.             b = n1-n3
  161.             
  162.             normal2 = a.cross(b)
  163.             normal2.normalize()
  164.             
  165.             # Reuse normal1 var
  166.             normal1 += normal1 + normal2
  167.             normal1.normalize()
  168.             
  169.             e.normal = normal1
  170.             #print e.normal
  171.  
  172.  
  173.         
  174.     def backup(self):
  175.         # Keep a backup of the edges
  176.         self.backup_edges = self.edges[:]
  177.             
  178.     def restore(self):
  179.         self.edges = self.backup_edges[:]
  180.         for e in self.edges:
  181.             e.removed = 0
  182.         
  183.     def reverse(self):
  184.         self.edges.reverse()
  185.         self.normal.negate()
  186.         
  187.         for e in self.edges:
  188.             e.normal.negate()
  189.             e.v1, e.v2 = e.v2, e.v1
  190.             e.co1, e.co2 = e.co2, e.co1
  191.             e.next, e.prev = e.prev, e.next
  192.         
  193.     
  194.     def removeSmallest(self, cullNum, otherLoopLen):
  195.         '''
  196.         Removes N Smallest edges and backs up the loop,
  197.         this is so we can loop between 2 loops as if they are the same length,
  198.         backing up and restoring incase the loop needs to be skinned with another loop of a different length.
  199.         '''
  200.         global CULL_METHOD
  201.         if CULL_METHOD == 1: # Shortest edge
  202.             eloopCopy = self.edges[:]
  203.             
  204.             # Length sort, smallest first
  205.             try:    eloopCopy.sort(key = lambda e1: e1.length)
  206.             except:    eloopCopy.sort(lambda e1, e2: cmp(e1.length, e2.length ))
  207.             
  208.             # Dont use atm
  209.             #eloopCopy.sort(lambda e1, e2: cmp(e1.angle*e1.length, e2.angle*e2.length)) # Length sort, smallest first
  210.             #eloopCopy.sort(lambda e1, e2: cmp(e1.angle, e2.angle)) # Length sort, smallest first
  211.             
  212.             remNum = 0
  213.             for i, e in enumerate(eloopCopy):
  214.                 if not e.fake:
  215.                     e.removed = 1
  216.                     self.edges.remove( e ) # Remove from own list, still in linked list.
  217.                     remNum += 1
  218.                 
  219.                     if not remNum < cullNum:
  220.                         break
  221.             
  222.         else: # CULL METHOD is even
  223.                 
  224.             culled = 0
  225.             
  226.             step = int(otherLoopLen / float(cullNum)) * 2
  227.             
  228.             currentEdge = self.edges[0]
  229.             while culled < cullNum:
  230.                 
  231.                 # Get the shortest face in the next STEP
  232.                 step_count= 0
  233.                 bestAng= 360.0
  234.                 smallestEdge= None
  235.                 while step_count<=step or smallestEdge==None:
  236.                     step_count+=1
  237.                     if not currentEdge.removed: # 0 or -1 will not be accepted
  238.                         if currentEdge.angle<bestAng and not currentEdge.fake:
  239.                             smallestEdge= currentEdge
  240.                             bestAng= currentEdge.angle
  241.                     
  242.                     currentEdge = currentEdge.next
  243.                 
  244.                 # In that stepping length we have the smallest edge.remove it
  245.                 smallestEdge.removed = 1
  246.                 self.edges.remove(smallestEdge)
  247.                 
  248.                 # Start scanning from the edge we found? - result is over fanning- no good.
  249.                 #currentEdge= smallestEdge.next
  250.                 
  251.                 culled+=1
  252.     
  253.  
  254. # Returns face edges.
  255. # face must have edge data.
  256.  
  257. def getSelectedEdges(me, ob):    
  258.     MESH_MODE= Blender.Mesh.Mode()
  259.     
  260.     if MESH_MODE & Blender.Mesh.SelectModes.EDGE or MESH_MODE & Blender.Mesh.SelectModes.VERTEX:
  261.         Blender.Mesh.Mode(Blender.Mesh.SelectModes.EDGE)
  262.         edges= [ ed for ed in me.edges if ed.sel ]
  263.         # print len(edges), len(me.edges)
  264.         Blender.Mesh.Mode(MESH_MODE)
  265.         return edges
  266.     
  267.     elif MESH_MODE & Blender.Mesh.SelectModes.FACE:
  268.         Blender.Mesh.Mode(Blender.Mesh.SelectModes.EDGE)
  269.         
  270.         # value is [edge, face_sel_user_in]
  271.         '''
  272.         try: # Python 2.4 only
  273.             edge_dict=  dict((ed.key, [ed, 0]) for ed in me.edges)
  274.         except:
  275.         '''
  276.         # Cant try 2.4 syntax because python 2.3 will complain still
  277.         edge_dict=  dict([(ed.key, [ed, 0]) for ed in me.edges])
  278.         
  279.         for f in me.faces:
  280.             if f.sel:
  281.                 for edkey in f.edge_keys:
  282.                     edge_dict[edkey][1] += 1
  283.         
  284.         Blender.Mesh.Mode(MESH_MODE)
  285.         return [ ed_data[0] for ed_data in edge_dict.itervalues() if ed_data[1] == 1 ]
  286.     
  287.     
  288.  
  289. def getVertLoops(selEdges, me):
  290.     '''
  291.     return a list of vert loops, closed and open [(loop, closed)...]
  292.     '''
  293.     
  294.     mainVertLoops = []
  295.     # second method
  296.     tot = len(me.verts)
  297.     vert_siblings = [[] for i in xrange(tot)]
  298.     vert_used = [False] * tot
  299.     
  300.     for ed in selEdges:
  301.         i1, i2 = ed.key
  302.         vert_siblings[i1].append(i2)
  303.         vert_siblings[i2].append(i1)
  304.     
  305.     # find the first used vert and keep looping.
  306.     for i in xrange(tot):
  307.         if vert_siblings[i] and not vert_used[i]:
  308.             sbl = vert_siblings[i] # siblings
  309.             
  310.             if len(sbl) > 2:
  311.                 return None
  312.             
  313.             vert_used[i] = True
  314.             
  315.             # do an edgeloop seek
  316.             if len(sbl) == 2:
  317.                 contextVertLoop= [sbl[0], i, sbl[1]] # start the vert loop
  318.                 vert_used[contextVertLoop[ 0]] = True
  319.                 vert_used[contextVertLoop[-1]] = True
  320.             else:
  321.                 contextVertLoop= [i, sbl[0]]
  322.                 vert_used[contextVertLoop[ 1]] = True
  323.             
  324.             # Always seek up
  325.             ok = True
  326.             while ok:
  327.                 ok = False
  328.                 closed = False
  329.                 sbl = vert_siblings[contextVertLoop[-1]]
  330.                 if len(sbl) == 2:
  331.                     next = sbl[not sbl.index( contextVertLoop[-2] )]
  332.                     if vert_used[next]:
  333.                         closed = True
  334.                         # break
  335.                     else:
  336.                         contextVertLoop.append( next ) # get the vert that isnt the second last
  337.                         vert_used[next] = True
  338.                         ok = True
  339.             
  340.             # Seek down as long as the starting vert was not at the edge.
  341.             if not closed and len(vert_siblings[i]) == 2:
  342.                 
  343.                 ok = True
  344.                 while ok:
  345.                     ok = False
  346.                     sbl = vert_siblings[contextVertLoop[0]]
  347.                     if len(sbl) == 2:
  348.                         next = sbl[not sbl.index( contextVertLoop[1] )]
  349.                         if vert_used[next]:
  350.                             closed = True
  351.                         else:
  352.                             contextVertLoop.insert(0, next) # get the vert that isnt the second last
  353.                             vert_used[next] = True
  354.                             ok = True
  355.             
  356.             mainVertLoops.append((contextVertLoop, closed))
  357.     
  358.     
  359.     verts = me.verts
  360.     # convert from indicies to verts
  361.     # mainVertLoops = [([verts[i] for i in contextVertLoop], closed) for contextVertLoop, closed in  mainVertLoops]
  362.     # print len(mainVertLoops)
  363.     return mainVertLoops
  364.     
  365.  
  366.  
  367. def skin2EdgeLoops(eloop1, eloop2, me, ob, MODE):
  368.     
  369.     new_faces= [] # 
  370.     
  371.     # Make sure e1 loops is bigger then e2
  372.     if len(eloop1.edges) != len(eloop2.edges):
  373.         if len(eloop1.edges) < len(eloop2.edges):
  374.             eloop1, eloop2 = eloop2, eloop1
  375.         
  376.         eloop1.backup() # were about to cull faces
  377.         CULL_FACES = len(eloop1.edges) - len(eloop2.edges)
  378.         eloop1.removeSmallest(CULL_FACES, len(eloop1.edges))
  379.     else:
  380.         CULL_FACES = 0
  381.     # First make sure poly vert loops are in sync with eachother.
  382.     
  383.     # The vector allong which we are skinning.
  384.     skinVector = eloop1.centre - eloop2.centre
  385.     
  386.     loopDist = skinVector.length
  387.     
  388.     # IS THE LOOP FLIPPED, IF SO FLIP BACK. we keep it flipped, its ok,
  389.     if eloop1.closed or eloop2.closed:
  390.         angleBetweenLoopNormals = AngleBetweenVecs(eloop1.normal, eloop2.normal)
  391.         if angleBetweenLoopNormals > 90:
  392.             eloop2.reverse()
  393.             
  394.  
  395.         DIR= eloop1.centre - eloop2.centre
  396.         
  397.         # if eloop2.closed:
  398.         bestEloopDist = BIG_NUM
  399.         bestOffset = 0
  400.         # Loop rotation offset to test.1
  401.         eLoopIdxs = range(len(eloop1.edges))
  402.         for offset in xrange(len(eloop1.edges)):
  403.             totEloopDist = 0 # Measure this total distance for thsi loop.
  404.             
  405.             offsetIndexLs = eLoopIdxs[offset:] + eLoopIdxs[:offset] # Make offset index list
  406.             
  407.             
  408.             # e1Idx is always from 0uu to N, e2Idx is offset.
  409.             for e1Idx, e2Idx in enumerate(offsetIndexLs):
  410.                 e1= eloop1.edges[e1Idx]
  411.                 e2= eloop2.edges[e2Idx]
  412.                 
  413.                 
  414.                 # Include fan connections in the measurement.
  415.                 OK= True
  416.                 while OK or e1.removed:
  417.                     OK= False
  418.                     
  419.                     # Measure the vloop distance ===============
  420.                     diff= ((e1.cent - e2.cent).length) #/ nangle1
  421.                     
  422.                     ed_dir= e1.cent-e2.cent
  423.                     a_diff= AngleBetweenVecs(DIR, ed_dir)/18 # 0 t0 18
  424.                     
  425.                     totEloopDist += (diff * (1+a_diff)) / (1+loopDist)
  426.                     
  427.                     # Premeture break if where no better off
  428.                     if totEloopDist > bestEloopDist:
  429.                         break
  430.                     
  431.                     e1=e1.next
  432.                     
  433.             if totEloopDist < bestEloopDist:
  434.                 bestOffset = offset
  435.                 bestEloopDist = totEloopDist
  436.         
  437.         # Modify V2 LS for Best offset
  438.         eloop2.edges = eloop2.edges[bestOffset:] + eloop2.edges[:bestOffset]
  439.             
  440.     else:
  441.         # Both are open loops, easier to calculate.
  442.         
  443.         
  444.         # Make sure the fake edges are at the start.
  445.         for i, edloop in enumerate((eloop1, eloop2)):
  446.             # print "LOOPO"
  447.             if edloop.edges[0].fake:
  448.                 # alredy at the start
  449.                 #print "A"
  450.                 pass
  451.             elif edloop.edges[-1].fake:
  452.                 # put the end at the start
  453.                 edloop.edges.insert(0, edloop.edges.pop())
  454.                 #print "B"
  455.                 
  456.             else:
  457.                 for j, ed in enumerate(edloop.edges):
  458.                     if ed.fake:
  459.                         #print "C"
  460.                         edloop.edges = edloop.edges = edloop.edges[j:] + edloop.edges[:j]
  461.                         break
  462.         # print "DONE"
  463.         ed1, ed2 = eloop1.edges[0], eloop2.edges[0]
  464.         
  465.         if not ed1.fake or not ed2.fake:
  466.             raise "Error"
  467.         
  468.         # Find the join that isnt flipped (juts like detecting a bow-tie face)
  469.         a1 = (ed1.co1 - ed2.co1).length + (ed1.co2 - ed2.co2).length
  470.         a2 = (ed1.co1 - ed2.co2).length + (ed1.co2 - ed2.co1).length
  471.         
  472.         if a1 > a2:
  473.             eloop2.reverse()
  474.             # make the first edge the start edge still
  475.             eloop2.edges.insert(0, eloop2.edges.pop())
  476.     
  477.     
  478.     
  479.     
  480.     for loopIdx in xrange(len(eloop2.edges)):
  481.         e1 = eloop1.edges[loopIdx]
  482.         e2 = eloop2.edges[loopIdx]
  483.         
  484.         # Remember the pairs for fan filling culled edges.
  485.         e1.match = e2; e2.match = e1
  486.         
  487.         if not (e1.fake or e2.fake):
  488.             new_faces.append([e1.v1, e1.v2, e2.v2, e2.v1])
  489.     
  490.     # FAN FILL MISSING FACES.
  491.     if CULL_FACES:
  492.         # Culled edges will be in eloop1.
  493.         FAN_FILLED_FACES = 0
  494.         
  495.         contextEdge = eloop1.edges[0] # The larger of teh 2
  496.         while FAN_FILLED_FACES < CULL_FACES:
  497.             while contextEdge.next.removed == 0:
  498.                 contextEdge = contextEdge.next
  499.             
  500.             vertFanPivot = contextEdge.match.v2
  501.             
  502.             while contextEdge.next.removed == 1:
  503.                 #if not contextEdge.next.fake:
  504.                 new_faces.append([contextEdge.next.v1, contextEdge.next.v2, vertFanPivot])
  505.                 
  506.                 # Should we use another var?, this will work for now.
  507.                 contextEdge.next.removed = 1
  508.                 
  509.                 contextEdge = contextEdge.next
  510.                 FAN_FILLED_FACES += 1
  511.         
  512.         # may need to fan fill backwards 1 for non closed loops.
  513.         
  514.         eloop1.restore() # Add culled back into the list.
  515.     
  516.     return new_faces
  517.  
  518. def main():
  519.     global CULL_METHOD
  520.     
  521.     is_editmode = Window.EditMode()
  522.     if is_editmode: Window.EditMode(0)
  523.     ob = bpy.data.scenes.active.objects.active
  524.     if ob == None or ob.type != 'Mesh':
  525.         BPyMessages.Error_NoMeshActive()
  526.         return
  527.     
  528.     me = ob.getData(mesh=1)
  529.     
  530.     if me.multires:
  531.         BPyMessages.Error_NoMeshMultiresEdit()
  532.         return
  533.     
  534.     time1 = Blender.sys.time()
  535.     selEdges = getSelectedEdges(me, ob)
  536.     vertLoops = getVertLoops(selEdges, me) # list of lists of edges.
  537.     if vertLoops == None:
  538.         PupMenu('Error%t|Selection includes verts that are a part of more then 1 loop')
  539.         if is_editmode: Window.EditMode(1)
  540.         return
  541.     # print len(vertLoops)
  542.     
  543.     
  544.     if len(vertLoops) > 2:
  545.         choice = PupMenu('Loft '+str(len(vertLoops))+' edge loops%t|loop|segment')
  546.         if choice == -1:
  547.             if is_editmode: Window.EditMode(1)
  548.             return
  549.     elif len(vertLoops) < 2:
  550.         PupMenu('Error%t|No Vertloops found!')
  551.         if is_editmode: Window.EditMode(1)    
  552.         return
  553.     else:
  554.         choice = 2
  555.     
  556.     
  557.     # The line below checks if any of the vert loops are differenyt in length.
  558.     if False in [len(v[0]) == len(vertLoops[0][0]) for v in vertLoops]:
  559.         CULL_METHOD = PupMenu('Small to large edge loop distrobution method%t|remove edges evenly|remove smallest edges')
  560.         if CULL_METHOD == -1:
  561.             if is_editmode: Window.EditMode(1)
  562.             return
  563.         
  564.         if CULL_METHOD ==1: # RESET CULL_METHOD
  565.             CULL_METHOD = 0 # shortest
  566.         else:
  567.             CULL_METHOD = 1 # even
  568.     
  569.     
  570.     time1 = Blender.sys.time()
  571.     # Convert to special edge data.
  572.     edgeLoops = []
  573.     for vloop, closed in vertLoops:
  574.         edgeLoops.append(edgeLoop(vloop, me, closed))
  575.         
  576.     
  577.     # VERT LOOP ORDERING CODE
  578.     # "Build a worm" list - grow from Both ends
  579.     edgeOrderedList = [edgeLoops.pop()]
  580.     
  581.     # Find the closest.
  582.     bestSoFar = BIG_NUM
  583.     bestIdxSoFar = None
  584.     for edLoopIdx, edLoop in enumerate(edgeLoops):
  585.         l =(edgeOrderedList[-1].centre - edLoop.centre).length 
  586.         if l < bestSoFar:
  587.             bestIdxSoFar = edLoopIdx
  588.             bestSoFar = l
  589.             
  590.     edgeOrderedList.append( edgeLoops.pop(bestIdxSoFar) )
  591.     
  592.     # Now we have the 2 closest, append to either end-
  593.     # Find the closest.
  594.     while edgeLoops:
  595.         bestSoFar = BIG_NUM
  596.         bestIdxSoFar = None
  597.         first_or_last = 0 # Zero is first
  598.         for edLoopIdx, edLoop in enumerate(edgeLoops):
  599.             l1 =(edgeOrderedList[-1].centre - edLoop.centre).length 
  600.             
  601.             if l1 < bestSoFar:
  602.                 bestIdxSoFar = edLoopIdx
  603.                 bestSoFar = l1
  604.                 first_or_last = 1 # last
  605.             
  606.             l2 =(edgeOrderedList[0].centre - edLoop.centre).length 
  607.             if l2 < bestSoFar:
  608.                 bestIdxSoFar = edLoopIdx
  609.                 bestSoFar = l2
  610.                 first_or_last = 0 # last
  611.         
  612.         if first_or_last: # add closest Last
  613.             edgeOrderedList.append( edgeLoops.pop(bestIdxSoFar) )    
  614.         else: # Add closest First
  615.             edgeOrderedList.insert(0, edgeLoops.pop(bestIdxSoFar) )     # First
  616.     
  617.     faces = []
  618.     
  619.     for i in xrange(len(edgeOrderedList)-1):
  620.         faces.extend( skin2EdgeLoops(edgeOrderedList[i], edgeOrderedList[i+1], me, ob, 0) )
  621.     if choice == 1 and len(edgeOrderedList) > 2: # Loop
  622.         faces.extend( skin2EdgeLoops(edgeOrderedList[0], edgeOrderedList[-1], me, ob, 0) )
  623.     
  624.     # REMOVE SELECTED FACES.
  625.     MESH_MODE= Blender.Mesh.Mode()
  626.     if MESH_MODE & Blender.Mesh.SelectModes.EDGE or MESH_MODE & Blender.Mesh.SelectModes.VERTEX: pass
  627.     elif MESH_MODE & Blender.Mesh.SelectModes.FACE:
  628.         try: me.faces.delete(1, [ f for f in me.faces if f.sel ])
  629.         except: pass
  630.     
  631.     me.faces.extend(faces, smooth = True)
  632.     
  633.     print '\nSkin done in %.4f sec.' % (Blender.sys.time()-time1)
  634.     
  635.     
  636.     if is_editmode: Window.EditMode(1)
  637.  
  638. if __name__ == '__main__':
  639.     main()
  640.